// 包含顺序不能改
// clang-format off
#include "types.h"
#include "defs.h"
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
#include "proc.h"
#include "x86.h"
#include "syscall.h"
// clang-format on

// User code makes a system call with INT T_SYSCALL.
// System call number in %eax.
// Arguments on the stack, from the user call to the C
// library system call function. The saved user %esp points
// to a saved program counter, and then the first argument.

// Fetch the int at addr from the current process.
int fetchint(uint addr, int *ip) {
    struct proc *curproc = myproc();

    if (addr >= curproc->sz || addr + 4 > curproc->sz)
        return -1;
    *ip = *(int *)(addr);
    return 0;
}

// Fetch the nul-terminated string at addr from the current process.
// Doesn't actually copy the string - just sets *pp to point at it.
// Returns length of string, not including nul.
int fetchstr(uint addr, char **pp) {
    char *s, *ep;
    struct proc *curproc = myproc();

    if (addr >= curproc->sz)
        return -1;
    *pp = (char *)addr;
    ep = (char *)curproc->sz;
    for (s = *pp; s < ep; s++) {
        if (*s == 0)
            return s - *pp;
    }
    return -1;
}

// Fetch the nth 32-bit system call argument.
int argint(int n, int *ip) { return fetchint((myproc()->tf->esp) + 4 + 4 * n, ip); }

// Fetch the nth word-sized system call argument as a pointer
// to a block of memory of size bytes.  Check that the pointer
// lies within the process address space.
int argptr(int n, char **pp, int size) {
    int i;
    struct proc *curproc = myproc();

    if (argint(n, &i) < 0)
        return -1;
    if (size < 0 || (uint)i >= curproc->sz || (uint)i + size > curproc->sz)
        return -1;
    *pp = (char *)i;
    return 0;
}

// Fetch the nth word-sized system call argument as a string pointer.
// Check that the pointer is valid and the string is nul-terminated.
// (There is no shared writable memory, so the string can't change
// between this check and being used by the kernel.)
int argstr(int n, char **pp) {
    int addr;
    if (argint(n, &addr) < 0)
        return -1;
    return fetchstr(addr, pp);
}

extern int sys_chdir(void);
extern int sys_close(void);
extern int sys_dup(void);
extern int sys_exec(void);
extern int sys_exit(void);
extern int sys_fork(void);
extern int sys_fstat(void);
extern int sys_getpid(void);
extern int sys_kill(void);
extern int sys_link(void);
extern int sys_mkdir(void);
extern int sys_mknod(void);
extern int sys_open(void);
extern int sys_pipe(void);
extern int sys_read(void);
extern int sys_sbrk(void);
extern int sys_sleep(void);
extern int sys_unlink(void);
extern int sys_wait(void);
extern int sys_write(void);
extern int sys_uptime(void);
extern int sys_date(void);
extern int sys_alarm(void);
extern int sys_alarm_warpper(void);

static int (*syscalls[])(void) = {
    [SYS_fork] sys_fork,   [SYS_exit] sys_exit,     [SYS_wait] sys_wait,
    [SYS_pipe] sys_pipe,   [SYS_read] sys_read,     [SYS_kill] sys_kill,
    [SYS_exec] sys_exec,   [SYS_fstat] sys_fstat,   [SYS_chdir] sys_chdir,
    [SYS_dup] sys_dup,     [SYS_getpid] sys_getpid, [SYS_sbrk] sys_sbrk,
    [SYS_sleep] sys_sleep, [SYS_uptime] sys_uptime, [SYS_open] sys_open,
    [SYS_write] sys_write, [SYS_mknod] sys_mknod,   [SYS_unlink] sys_unlink,
    [SYS_link] sys_link,   [SYS_mkdir] sys_mkdir,   [SYS_close] sys_close,
    [SYS_date] sys_date,   [SYS_alarm] sys_alarm,   [SYS_alarm_warpper] sys_alarm_warpper};

// 是否启用带详细信息的系统调用
// #define VERBOSE_SYSCALL 0

#ifdef VERBOSE_SYSCALL

/* 系统调用名称解析 */
static const char *syscall_name[] = {
    [SYS_fork] "sys_fork",     [SYS_exit] "sys_exit",
    [SYS_wait] "sys_wait",     [SYS_pipe] "sys_pipe",
    [SYS_read] "sys_read",     [SYS_kill] "sys_kill",
    [SYS_exec] "sys_exec",     [SYS_fstat] "sys_fstat",
    [SYS_chdir] "sys_chdir",   [SYS_dup] "sys_dup",
    [SYS_getpid] "sys_getpid", [SYS_sbrk] "sys_sbrk",
    [SYS_sleep] "sys_sleep",   [SYS_uptime] "sys_uptime",
    [SYS_open] "sys_open",     [SYS_write] "sys_write",
    [SYS_mknod] "sys_mknod",   [SYS_unlink] "sys_unlink",
    [SYS_link] "sys_link",     [SYS_mkdir] "sys_mkdir",
    [SYS_close] "sys_close",   [SYS_date] "sys_date",
    [SYS_alarm] "sys_alarm",   [SYS_alarm_warpper] "SYS_alarm_warpper"};

/* 系统调用参数数量 */
static const int syscall_argnum[] = {
    [SYS_fork] 0,   [SYS_exit] 1,  [SYS_wait] 1,   [SYS_pipe] 1,         [SYS_read] 3,
    [SYS_kill] 2,   [SYS_exec] 3,  [SYS_fstat] 2,  [SYS_chdir] 1,        [SYS_dup] 1,
    [SYS_getpid] 0, [SYS_sbrk] 1,  [SYS_sleep] 1,  [SYS_uptime] 0,       [SYS_open] 2,
    [SYS_write] 3,  [SYS_mknod] 3, [SYS_unlink] 1, [SYS_link] 2,         [SYS_mkdir] 1,
    [SYS_close] 1,  [SYS_date] 1,  [SYS_alarm] 2,  [SYS_alarm_warpper] 7};

/* 带详细信息的系统调用 */
static void verbose_syscall(void) {
    struct proc *curproc = myproc();

    int id = curproc->tf->eax;
    int argnum = syscall_argnum[id];
    int ret = syscalls[id]();

    // 忽略读写, 简化输出.
    // if (id == SYS_read || id == SYS_write) {
    //     curproc->tf->eax = ret;
    //     return;
    // }

    cprintf("\n-----------------\n");
    cprintf("Syscall:\n");
    cprintf("  id = %d\n", id);
    cprintf("  name = %s\n", syscall_name[id]);
    cprintf("  argnum = %d\n", argnum);
    if (argnum > 0) {
        cprintf("    arg @%x\n", curproc->tf->esp);
    }
    for (int argid = 0; argid < argnum; argid++) {
        int argval = 0;
        argint(argid, &argval);

        cprintf("    arg #%d = %x\n", argid, argval);
    }
    cprintf("  ret = %x\n", ret);
    cprintf("-----------------\n");

    curproc->tf->eax = ret;
}

#endif

void syscall(void) {
    int num;
    struct proc *curproc = myproc();

    num = curproc->tf->eax;
    if (num > 0 && num < NELEM(syscalls) && syscalls[num]) {
#ifdef VERBOSE_SYSCALL
        verbose_syscall();
#else
        curproc->tf->eax = syscalls[num]();
#endif
    } else {
        cprintf("%d %s: unknown sys call %d\n", curproc->pid, curproc->name, num);
        curproc->tf->eax = -1;
    }
}
